'''
规律跑者数据整理流程
规律跑者的数据单独成表，
确定规律跑者开始时间，按照时间列表选择28天数据


数据类型有ecg，rr，huawei数据、竞品数据统一到一个列表，

选取28天每天两次的早晚静息形成数据集，空的为空即可

number、day、state、stage、starttime、endtime、polar_hr、polar_rr、竞品平均hr、竞品hrv、
gl1011、1、Morning、1、时间、          时间 、  列表、       列表 、   60、     xxx


选取12次跑步形成数据集
allstages：受试者编号、day、状态（早、晚、运前，运中、运后）、开始时间、结束时间、开始时间戳、结束时间戳、
kuaice-HR、kuaice-HRV、polar-hr（列表）、polar-rr（列表）、huawei-hr（列表）、huawei-rr（列表）、竞品hr（列表）、  
'''


'''
代码思路
1.将一个人相同类型的数据先合并到一个文件，ecg，rrdata、singleowrk、singledetail、kuaice、fit
2.标准制定、day如何制定，？？？？，最坏打算手动填写，或者直接在文件名称上标注标注
跑步过程制定：根据singlework确定跑步中，detail和fit，ecg中拿到跑步中hrrr，去ecg和rrdata拿到跑步前后的静息、
早晚静息制定：根据快测时间去ecg中选取：该阶段的数据

'''
import os
import pandas as pd
import re
from datetime import datetime, timedelta
from data_deal.function import get_stage_hr, get_stage_rr
from data_deal.merger import ecg_deal, singlework_deal,rrdata_deal

# 定义路径
# datapath = 'D:\\学习&科研\\华为手表项目\\华为数据\\规律跑者数据样例\\long_term_deal\\polar\\1016\\data'
datapath = 'D:\\学习&科研\\华为手表项目\\华为数据\\规律跑者数据样例\\long_term_deal\\polar\\1016\\rrdata'
singleworkpath = 'D:\\学习&科研\\华为手表项目\\华为数据\\规律跑者数据样例\\long_term_deal\\huawei-workouts\\1016-singleworkouts.csv'

def filepath_deal():
# 读取和处理 singlework_df 和 kuaice_df
    singlework_df = singlework_deal(singleworkpath)
    kuaice_df = pd.read_csv('D:\\学习&科研\\华为手表项目\\华为数据\\规律跑者数据样例\\long_term_deal\\healthtest\\1016-Coros-healthtest.csv')
    kuaice_df['datetime'] = kuaice_df['timestamp'].apply(lambda x: datetime.fromtimestamp(x))
    singlework_df = singlework_df.drop_duplicates()

    # 打印 DataFrame
    print(singlework_df)
    print(kuaice_df)

    # 读取文件夹中的文件并过滤小于2KB的文件,并删除
    files = os.listdir(datapath)
    filtered_files = []
    for file in files:
        file_path = os.path.join(datapath, file)
        if os.path.getsize(file_path) > 2048:
            filtered_files.append(file)
        else:
            os.remove(file_path)  # 删除小于2KB的文件

    file_df = pd.DataFrame(filtered_files, columns=['filename'])


    # 提取文件名中的时间信息并转换为 datetime 格式
    time_pattern = re.compile(r'-(\d{4}-\d{2}-\d{2}-\d{2}时\d{2}分\d{2}秒)')
    def extract_datetime(filename):
        match = time_pattern.search(filename)
        if match:
            time_str = match.group(1).replace('时', ':').replace('分', ':').replace('秒', '')
            return datetime.strptime(time_str, '%Y-%m-%d-%H:%M:%S')
        return None

    file_df['datetime'] = file_df['filename'].apply(extract_datetime)

    # 确保 singlework_df 中的时间列是 datetime 类型
    singlework_df['活动.测量开始时间'] = pd.to_datetime(singlework_df['活动.测量开始时间'])
    singlework_df['活动.测量结束时间'] = pd.to_datetime(singlework_df['活动.测量结束时间'])

    # 定义 get_state_and_times 函数
    def get_state_and_times(file_datetime):
        # 检查 singlework_df
        for index, row in singlework_df.iterrows():
            start_time = row['活动.测量开始时间']
            end_time = row['活动.测量结束时间']
            if abs(file_datetime - start_time) <= timedelta(minutes=30):
                return 'running', start_time, end_time
        
        # 检查 kuaice_df
        for index, row in kuaice_df.iterrows():
            start_time = row['datetime']
            end_time = start_time + timedelta(minutes=2)
            if abs(file_datetime - start_time) <= timedelta(minutes=30):
                return 'resting', start_time, end_time
        
        return 'not running', None, None

    # 应用 get_state_and_times 函数并打印结果
    file_df[['state', '活动.测量开始时间', '活动.测量结束时间']] = file_df['datetime'].apply(get_state_and_times).apply(pd.Series)

    # 定义 get_day 函数
    def get_day(dt, base_date):
        # 以凌晨5点为一天的起点
        day_start = datetime(dt.year, dt.month, dt.day, 5, 0, 0)
        if dt < day_start:
            day_start -= timedelta(days=1)
        return (day_start - base_date).days + 1

    # 找到最小的 datetime 作为基准日期
    min_datetime = file_df['datetime'].min()
    base_date = datetime(min_datetime.year, min_datetime.month, min_datetime.day, 5, 0, 0)
    if min_datetime < base_date:
        base_date -= timedelta(days=1)

    # 应用 get_day 函数
    file_df['day'] = file_df['datetime'].apply(lambda dt: get_day(dt, base_date))
    # 建立新的一列morning and evening，如果day相同，且state为resting，第一个数据的morning and evening列标记为morning，反之则evening
    # 筛选出 state 为 'resting' 的行
    resting_df = file_df[file_df['state'] == 'resting']

    # 按 day 分组，并对 datetime 排序
    resting_df = resting_df.sort_values(by=['day', 'datetime'])

    # 创建一个新的列 'morning_and_evening'，默认值为 'evening'
    resting_df['morning_and_evening'] = 'evening'

    # 标记每一天的第一个 'resting' 数据为 'morning'
    resting_df.loc[resting_df.groupby('day').head(1).index, 'morning_and_evening'] = 'morning'

    # 将标记结果合并回原 DataFrame
    file_df = pd.merge(file_df, resting_df[['filename', 'morning_and_evening']], on='filename', how='left')

    # 填充 'morning_and_evening' 中 NaN 值为 'state' 列中的对应值
    file_df['morning_and_evening'] = file_df['morning_and_evening'].fillna(file_df['state'])
    # 创建 savefile 列，格式为：filename 的前四个字符-day-morning_and_evening
    file_df['savefile'] = file_df.apply(lambda x: f"gl{x['filename'][:4]}-{x['day']}-{x['morning_and_evening']}", axis=1)
    # 将file_id_day_group_label加上.csv，重命名回命名文件，并写回文件区
    for index, row in file_df.iterrows():
        old_filename = os.path.join(datapath, row['filename'])
        new_filename = os.path.join(datapath, row['savefile'] + '.csv')
        os.rename(old_filename, new_filename)

    print(file_df)
    # file_df.to_csv('D:\\学习&科研\\华为手表项目\\华为数据\\规律跑者数据样例\\long_term_deal\\polar\\1016\\file_df.csv', index=False)


# filepath_deal()



def allstages_deal():
   

    # 获取 datapath 路径下的所有文件列表
    files = os.listdir(datapath)

    # 读取 singlework_df
    singlework_df = singlework_deal(singleworkpath)
    kuaice_df = pd.read_csv('D:\\学习&科研\\华为手表项目\\华为数据\\规律跑者数据样例\\long_term_deal\\healthtest\\1016-coros-healthtest.csv')
    kuaice_df['datetime'] = kuaice_df['timestamp'].apply(lambda x: datetime.fromtimestamp(x))
    

    # 创建一个 DataFrame 存储文件名和分解后的列
    file_df = pd.DataFrame(files, columns=['filename'])
    file_df['test'] = file_df['filename'].apply(lambda x: os.path.splitext(x)[0])
    file_df[['test_id', 'day', 'state']] = file_df['filename'].apply(lambda x: os.path.splitext(x)[0]).str.split('-', expand=True)

    # 定义函数提取活动开始时间和结束时间
    def get_activity_times(file_path):
        try:
            # 读取 CSV 文件
            # df = ecg_deal(file_path)  # 需要你定义这个处理函数
            df=rrdata_deal(file_path)

            # 提取第一行和最后一行的 ecg_timestamp
            start_time = df.iloc[0]['timestamp']
            end_time = df.iloc[-1]['timestamp']
            # 转换为 pandas datetime 格式
            start_time = pd.to_datetime(start_time, unit='ms')
            end_time = pd.to_datetime(end_time, unit='ms')
            start_time = start_time + timedelta(hours=8)
            end_time = end_time + timedelta(hours=8)
            return start_time, end_time
        except Exception as e:
            print(f"Error processing file {file_path}: {e}")
            return None, None
   
    # 获取活动开始时间和结束时间，并添加到 DataFrame 中
    file_df['file_path'] = file_df['filename'].apply(lambda x: os.path.join(datapath, x))
    file_df[['polar采集开始', 'polar采集结束']] = file_df['file_path'].apply(get_activity_times).apply(pd.Series)
    
    # 确保 singlework_df 的时间列是 pandas datetime 类型
    singlework_df['活动.测量开始时间'] = pd.to_datetime(singlework_df['活动.测量开始时间'])
    singlework_df['活动.测量结束时间'] = pd.to_datetime(singlework_df['活动.测量结束时间'])

    # 定义匹配活动开始时间和活动测量时间差距不超过30分钟的函数
    print('singlework')
    print(singlework_df)
    def match_running_times(row):
        file_start = row['polar采集开始']
        
        for _, single_row in singlework_df.iterrows():
            measure_start = single_row['活动.测量开始时间']
            measure_end = single_row['活动.测量结束时间']
            print(measure_start,measure_end)
            # 计算时间差
            time_diff = abs((measure_start - file_start).total_seconds())
            
            # 如果时间差在30分钟以内，则返回测量的开始和结束时间
            if time_diff <= 30 * 60:
                return pd.Series([measure_start, measure_end])
        
        # 如果没有匹配的时间段，返回 None
        return pd.Series([None, None])

    # 应用函数并将结果存入新的列
    file_df[['跑步开始时间', '跑步结束时间']] = file_df.apply(match_running_times, axis=1)



    #再增加两列kuaice-HR、kuaice-HRV，循环file_df中state非running的行的活动开始时间，与kuaice_df['datetime']匹配，时间差不超过10分钟，匹配到就把kuaice_df的HR	HRV，存入kuaice-HR、kuaice-HRV

    # 定义匹配 kuaice_df 中 HR 和 HRV 的函数
    def match_kuaice_times(row):
        if row['state'] != 'running':
            file_start = row['polar采集开始']
            for _, kuaice_row in kuaice_df.iterrows():
                kuaice_time = kuaice_row['datetime']
                time_diff = abs((kuaice_time - file_start).total_seconds())
                if time_diff <= 10 * 60:
                    return pd.Series([kuaice_row['HR'], kuaice_row['HRV']])
        return pd.Series([None, None])

    # 应用函数并将结果存入新的列
    file_df[['kuaice-HR', 'kuaice-HRV']] = file_df.apply(match_kuaice_times, axis=1)

    file_df[['全程hr','全程rr']]=None
    def get_activity_hr(file_path):
        try:
            # 读取 CSV 文件
            # df = ecg_deal(file_path)  # 需要你定义这个处理函数
            df=rrdata_deal(file_path)
            
            # 提取df中的hr作为列表
            hr_list = pd.to_numeric(df['HR'], errors='coerce').tolist()
            return hr_list

            
        except Exception as e:
            print(f"hr error {file_path}: {e}")
            return[]
    file_df['全程hr'] = file_df['file_path'].apply(get_activity_hr)
    
    def get_activity_rr(file_path):
        try:
            # 读取 CSV 文件
            # df = ecg_deal(file_path)  # 需要你定义这个处理函数
            df=rrdata_deal(file_path)
            
            # 提取df中的hr作为列表
            rr_list = df['rr'].to_list()
            flattened_list = [int(item) for sublist in rr_list for item in sublist if item and item.strip().isdigit()]
            print('rrlist',flattened_list)
            return flattened_list

            
        except Exception as e:
            print(f"rr error {file_path}: {e}")
            return []
    file_df['全程rr'] = file_df['file_path'].apply(get_activity_rr)
    # get_stage_rr()
    #按照时间节点，分别找出rr和hr，及rpe的范围，1静息的全程，2跑步前静息、3跑步全程、4跑后静息
    # 打印结果
    # print(file_df[['filename','活动开始时间', '活动结束时间', '跑步开始时间', '跑步结束时间']])
    #按照polar采集开始排序
    file_df = file_df.sort_values(by='polar采集开始')
    file_df[['test_id','day','state','polar采集开始','polar采集结束','跑步开始时间','跑步结束时间','全程hr','全程rr',]].to_csv('D:\\学习&科研\\华为手表项目\\华为数据\\规律跑者数据样例\\long_term_deal\\polar\\1016\\allstage_df.csv', index=False)
    
    
    print(file_df)


# filepath_deal()
allstages_deal()
    # 打印结果


    #对于running 去singlework中查找跑步开始和结束时间，活动开始到跑步开始记录为静息数据，跑步开始到结束记为跑步数据，跑步结束到活动结束记为跑后静息数据

    # 打印结果
















# print(file_df)
